package com.kasa.zto;

/**
 * <p>Title: </p>
 *
 * <p>Description: </p>
 *
 * <p>Copyright: Copyright (c) 2007</p>
 *
 * <p>Company: </p>
 *
 * @author not attributable
 * @version 1.0
 */
public class NumberUtils
{
    /**
     * int 类型数据变成字节数组
     */
    public static byte[] int2byte(int n)
    {
        byte b[] = new byte[4];
        b[0] = (byte) (n >> 24);
        b[1] = (byte) (n >> 16);
        b[2] = (byte) (n >> 8);
        b[3] = (byte) n;
        return b;
    }

    /**
     * 字节数字转换成int
     *
     * @param b
     *            要转换的字节数组
     * @return 转换后的int类型
     */
    public static int byte2int(byte[] b)
    {
        return byte2int(b, 0);
    }

    /**
     * 字节数字转换成int
     *
     * @param b
     *            要转换的字节数组
     * @param offset
     *            字节数字起始位置
     * @return 转换后的int类型
     */
    public static int byte2int(byte[] b, int offset)
    {
        return b[3 + offset] & 0xff | (b[2 + offset] & 0xff) << 8
            | (b[1 + offset] & 0xff) << 16 | (b[0 + offset] & 0xff) << 24;
    }

    /**
     * short 类型数据变成字节数组
     */
    public static byte[] short2byte(int n)
    {
        byte b[] = new byte[2];
        b[0] = (byte) (n >> 8);
        b[1] = (byte) n;
        return b;
    }

    /**
     * 字节数字转换成short
     *
     * @param b
     *            要转换的字节数组
     * @return 转换后的short类型
     */
    public static short byte2short(byte[] b)
    {
        return byte2short(b, 0);
    }

    /**
     * 字节数字转换成short
     *
     * @param b
     *            要转换的字节数组
     * @param offset
     *            字节数字起始位置
     * @return 转换后的short类型
     */
    public static short byte2short(byte b[], int offset)
    {
        return (short) (b[1 + offset] & 0xff | (b[offset] & 0xff) << 8);
    }

    /**
     * 长整型换成字节数组
     *
     * @param 要转换的数据
     * @return 转换后的字节数字
     */
    public static byte[] long2byte(long n)
    {
        byte b[] = new byte[8];
        b[0] = (byte) (n >> 56);
        b[1] = (byte) (n >> 48);
        b[2] = (byte) (n >> 40);
        b[3] = (byte) (n >> 32);
        b[4] = (byte) (n >> 24);
        b[5] = (byte) (n >> 16);
        b[6] = (byte) (n >> 8);
        b[7] = (byte) n;
        return b;
    }

    /**
     * 字节数字转换成long
     *
     * @param b
     *            要转换的字节数组
     * @return 转换后的long类型
     */
    public static long byte2long(byte[] b)
    {
        return byte2long(b, 0);
    }

    /**
     * 字节数字转换成long
     *
     * @param b
     *            要转换的字节数组
     * @param offset
     *            字节数字起始位置
     * @return 转换后的long类型
     */
    public static long byte2long(byte b[], int offset)
    {
        return (long) b[offset + 7] & 0xff
            | ((long) b[offset + 6] & 0xff) << 8
            | ((long) b[offset + 5] & 0xff) << 16
            | ((long) b[offset + 4] & 0xff) << 24
            | ((long) b[offset + 3] & 0xff) << 32
            | ((long) b[offset + 2] & 0xff) << 40
            | ((long) b[offset + 1] & 0xff) << 48
            | (long) b[offset] << 56;
    }
}
